home *** CD-ROM | disk | FTP | other *** search
/ Java Programmer's Toolkit / Java Programmer's Toolkit.iso / hotjava / classsrc / java / io / inputs~1.jav < prev    next >
Encoding:
Text File  |  1995-08-11  |  4.6 KB  |  158 lines
  1. /*
  2.  * @(#)InputStream.java    1.9 95/01/31 Arthur van Hoff
  3.  *
  4.  * Copyright (c) 1994 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Permission to use, copy, modify, and distribute this software
  7.  * and its documentation for NON-COMMERCIAL purposes and without
  8.  * fee is hereby granted provided that this copyright notice
  9.  * appears in all copies. Please refer to the file "copyright.html"
  10.  * for further important copyright and licensing information.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
  13.  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  14.  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  15.  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
  16.  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  17.  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
  18.  */
  19.  
  20. package java.io;
  21.  
  22. /**
  23.  * Abstract class representing an input stream of bytes.
  24.  * All InputStreams are based on this class.
  25.  * @see        OutputStream
  26.  * @see        FilterInputStream
  27.  * @see        BufferedInputStream
  28.  * @see        DataInputStream
  29.  * @see        InputStreamBuffer
  30.  * @see        PushbackInputStream
  31.  * @version     1.9, 31 Jan 1995
  32.  * @author    Arthur van Hoff
  33.  */
  34. public
  35. class InputStream {
  36.     /**
  37.      * Reads a byte. Will block if no input is available.
  38.      * @return     the byte read, or -1 if the end of the
  39.      *        stream is reached.
  40.      * @exception IOException i/o error occurred
  41.      */
  42.     public abstract int read();
  43.  
  44.     /**
  45.      * Reads into an array of bytes.
  46.      * Blocks until some input is available.
  47.      * @param b    the buffer into which the data is read
  48.      * @return  the actual number of bytes read, -1 is
  49.      *         returned when the end of the stream is reached.
  50.      * @exception IOException i/o error occurred
  51.      */
  52.     public int read(byte b[]) {
  53.     return read(b, 0, b.length);
  54.     }
  55.  
  56.     /**
  57.      * Reads into an array of bytes.
  58.      * Blocks until some input is available.
  59.      * For efficiency, this method should be overridden in a subclass
  60.      * (the default implementation reads 1 byte
  61.      * at a time).
  62.      * @param b    the buffer into which the data is read
  63.      * @param off the start offset of the data
  64.      * @param len the maximum number of bytes read
  65.      * @return  the actual number of bytes read, -1 is
  66.      *         returned when the end of the stream is reached.
  67.      * @exception IOException i/o error occurred
  68.      */
  69.     public int read(byte b[], int off, int len) {
  70.     if (len <= 0) {
  71.         return 0;
  72.     }
  73.  
  74.     int c = read();
  75.     if (c == -1) {
  76.         return -1;
  77.     }
  78.     b[off] = (byte)c;
  79.  
  80.     int i = 1;
  81.     try {
  82.         for (; i < len ; i++) {
  83.         c = read();
  84.         if (c == -1) {
  85.             break;
  86.         }
  87.         if (b != null) {
  88.             b[off + i] = (byte)c;
  89.         }
  90.         }
  91.     } catch (IOException ee) {
  92.     }
  93.     return i;
  94.     }
  95.  
  96.     /**
  97.      * Skips bytes of input.
  98.      * @param n     bytes to be skipped
  99.      * @return    actual number of bytes skipped
  100.      * @exception IOException i/o error occurred
  101.      */
  102.     public int skip(int n) {
  103.     byte data[] = new byte[n];
  104.     return read(data);
  105.     }
  106.  
  107.     /**
  108.      * Returns the number of bytes that can be read
  109.      * without blocking.
  110.      * @return the number of available bytes
  111.      */
  112.     public int available() {
  113.     return 0;
  114.     }
  115.  
  116.     /**
  117.      * Closes the input stream. Must be called
  118.      * to release any resources associated with
  119.      * the stream.
  120.      * @exception IOException i/o error occurred
  121.      */
  122.     public void close() {
  123.     }
  124.  
  125.     /**
  126.      * Marks the current position in the input stream.  A subsequent
  127.      * call to reset() will reposition the stream at the last
  128.      * marked position so that subsequent reads will re-read
  129.      * the same bytes.  The stream promises to allow readlimit bytes
  130.      * to be read before the mark position gets invalidated.
  131.      */
  132.     public synchronized void mark(int readlimit) {
  133.     }
  134.  
  135.     /**
  136.      * Repositions the stream to the last marked position.  If the
  137.      * stream has not been marked, or if the mark has been invalidated,
  138.      * an IOException is thrown.  Stream marks are intended to be used in
  139.      * situations where you need to read ahead a little to see what's in
  140.      * the stream.  Often this is most easily done by invoking some
  141.      * general parser.  If the stream is of the type handled by the
  142.      * parse, it just chugs along happily.  If the stream is *not* of
  143.      * that type, the parser should toss an exception when it fails,
  144.      * which, if it happens within readlimit bytes, allows the outer
  145.      * code to reset the stream and try another parser.
  146.      */
  147.     public synchronized void reset() {
  148.     throw new IOException("mark/reset not supported");
  149.     }
  150.  
  151.     /**
  152.      * Returns true if this stream type supports mark/reset
  153.      */
  154.     public boolean markSupported() {
  155.     return false;
  156.     }
  157. }
  158.